const { Controller } = require("egg");
const fs = require("fs");
const path = require("path");
const dayjs = require('dayjs');

class HomeController extends Controller {
  async default() {
    const { ctx } = this;
    const filePath = path.join(this.config.baseDir, "dist", "index.html");

    try {
      const html = fs.readFileSync(filePath, "utf8");
      ctx.body = html;
      ctx.type = "html";
    } catch (e) {
      ctx.status = 404;
      ctx.body = "Page Not Found";
    }
  }
  /**
   * 主消息处理入口，根据 event 类型执行对应逻辑
   */
  // 原始版
  async index() {
    const { ctx, service } = this;
    const payload = ctx.request.body;
    const event = payload.event;
    const msgtype = payload.data.data.msgType;
    const msg = payload.data.data.msg;
    const mywxid = payload.wxid;
    const fromWxid = payload.data.data.fromWxid;

    // 判断消息是否需要转发 保存需要转发的消息
    const forward = await service.forward.searchForward(mywxid, fromWxid);
    if (forward) {
      await service.forward.createForwardTask(
        mywxid,
        forward.fromwxid,
        msgtype,
        msg
      );
    }

    // 不转发时的处理 根据event的值来分别处理
    if (fromWxid !== "weixin" && fromWxid !== "filehelper") {
      switch (event) {
        case 10008:
          // 群聊
          this.event1008(payload);
          break;

        case 10009:
          // 私聊
          this.event1009(payload);
          break;

        case 10010:
          // 系统通知
          this.event10010(payload);
          break;

        case 10006:
          // 转账事件
          this.event1006(payload);
          break;

        case 10013:
          this.event10013(payload);
          break;

        case 10011:
          // 好友请求
          this.event10011(payload);
          break;

        case 10007:
          console.log("支付事件:", event);
          break;

        case 10015:
          console.log("二维码收款事件:", event);

          break;

        case 10016:
          console.log("群成员变动:", event);

          break;

        case 10:
          console.log("心跳:", event);

          break;

        case 99999:
          console.log("千寻授权到期:", event);

          break;

        case 10014:
          console.log("账号变动事件:", event);
          const type = payload.data.type || 0;
          if (type === 1) {
            console.log("账号上线");
          } else {
            console.log("账号下线");
          }
          break;

        default:
          console.log("其它:", event);
          break;
      }
    }
  }

  /**
   * 处理转账事件（event=10006）
   * 主要负责：
   * - 转账记录存储
   * - 自动收款逻辑（如果开启）
   * - 自动确认收款后财务日志记录
   * - 根据金额判断是否增加会员时间
   */
  async event1006(payload) {
    const { ctx, service } = this;
    const data = payload.data.data;
    const wxid = payload.data.wxid;

    // 1. 存储转账记录到数据库
    const saveResult = await service.wxtranspay.create(payload.data);
    if (!saveResult) {
      ctx.logger.warn("转账记录存储失败", { wxid, fromWxid: data.fromWxid });
      return;
    }

    ctx.logger.info("转账事件保存成功:", saveResult._id);

    // 2. 如果是对方发起的转账，检查是否开启自动收款
    if (data.msgSource === 1) {
      const friend = await ctx.model.Wxfriend.findOne({
        wxid: data.fromWxid,
        ownerWxid: wxid,
      });

      if (!friend || !friend.isconfirmpay) {
        ctx.logger.info(`${data.fromWxid} 未开启自动收款`);
        return;
      }

      // 3. 执行自动确认收款
      const confirmResult = await service.wxfriend.confirmTrans(
        wxid,
        data.fromWxid,
        data.transcationid,
        data.transferid
      );
      if (confirmResult.code !== 200) {
        ctx.logger.warn("自动确认收款失败", confirmResult);
        return;
      }

      // 4. 记录财务日志
      const money = parseFloat(data.money);
      const accountLog = {
        wxfId: friend._id,
        ownerWxid: wxid,
        wxid: friend.wxid,
        nick: friend.nick,
        amount: money,
        remark: data.memo || "转账",
      };

      await ctx.model.Account.create(accountLog);
      // 5. 查询会员配置并更新会员时间
      const vipConfig = await ctx.model.Vipconfig.findOne({ ownerWxid: wxid });
      if (!vipConfig) {
        ctx.logger.warn("未找到会员配置", { ownerWxid: wxid });
        return;
      }

      let increaseDays = 0;

      if (money === vipConfig.month) {
        increaseDays = 30;
      } else if (money === vipConfig.quarter) {
        increaseDays = 90;
      } else if (money === vipConfig.year) {
        increaseDays = 365;
      }

      if (increaseDays > 0) {
        let baseTime;

        // 判断是否为有效会员
        if (friend.isvip) {
          // 是会员：使用原有到期时间 或 当前时间（防止非法日期）
          if (
            friend.vipExpireTime &&
            friend.vipExpireTime instanceof Date &&
            !isNaN(friend.vipExpireTime)
          ) {
            baseTime = new Date(friend.vipExpireTime);
          } else {
            baseTime = new Date(); // 防御性处理，避免空值导致错误
          }

          const newExpireTime = new Date(baseTime);
          newExpireTime.setDate(baseTime.getDate() + increaseDays);

          await ctx.model.Wxfriend.updateOne(
            { _id: friend._id },
            {
              $set: {
                isvip: true,
                vipExpireTime: newExpireTime,
              },
            }
          );

          // 这里需要通过消息回复的方式告知用户会员时间已延长
          const formattedExpireTime = dayjs(newExpireTime).format('YYYY-MM-DD HH:mm:ss')
          await ctx.service.sendmsg.sendText2(
            friend.wxid,
            `会员时间已延长 ${increaseDays} 天\r\n到期:${formattedExpireTime}`,
            wxid
          );

          ctx.logger.info(`会员时间已延长 ${increaseDays} 天`, {
            wxid: friend.wxid,
            newExpireTime,
          });
        } else {
          // 不是会员：从当前时间开始计算
          ctx.logger.info('非会员转账')
        }
      }
    }
  }
  async event1008(payload) {
    const { ctx, service } = this;
    const fromWxid = payload.fromWxid;
    const wxid = payload.wxid;
    const msgtypeText = await service.chatmsg.isMsgType(
      payload.data.data.msgType
    );

    const groupInfo = await service.wxgroup.getGroupinfo(fromWxid);
    if (groupInfo && groupInfo.issave) {
      const roomres = await service.wxchatroomdb.create(payload.data);
      if (roomres) {
        // 有的时候找不到群信息 暂时不处理
        // await service.wxgroup.editGroup(mywxid, fromWxid, {
        //   ischat: true,
        // });
        console.log("群聊消息存储成功:", wxid, msgtypeText, roomres.date);
      }
    } else {
      console.log("不保存");
    }
  }

  async event1009(payload) {
    const { ctx, service } = this;
    const fromWxid = payload.fromWxid;
    const mywxid = payload.wxid;
    const msgtypeText = await service.chatmsg.isMsgType(
      payload.data.data.msgType
    );
    const msg = payload.data.data.msg;
    // 定义默认好友状态字段
    const field = {
      isfriend: false,
    };

    // 判断消息内容以识别不同类型的好友相关事件
    if (msg.includes("weixin://findfriend/verifycontact")) {
      /**
       * 场景：收到好友请求但尚未通过
       * 操作：标记该联系人为“非好友”
       */
      await service.wxfriend.editFriend(mywxid, fromWxid, field);
    } else if (msg.includes("我通过了你的朋友验证请求")) {
      /**
       * 场景：对方已通过我们的好友请求
       * 操作：
       * 1. 查询当前用户与对方的好友记录
       * 2. 更新手机号数据库中的好友状态为“已添加”
       * 3. 发送自动回复消息
       */

      // 1. 查询好友信息
      const friendinfo = await ctx.model.Wxfriend.findOne({
        ownerWxid: mywxid,
        wxid: fromWxid,
      });

      console.log("我通过了你的朋友验证请求");

      // 2. 更新 phonedb 中对应记录为已添加好友
      await service.phonedb.editPhonefromFwxid(mywxid, friendinfo.v3, {
        isfriend: true,
      });

      // 3. 自动发送欢迎消息
      const autoSendText = "你好！";
      await service.sendtext.sendText2(mywxid, autoSendText, fromWxid);
    } else {
      /**
       * 场景：普通私聊消息
       * 操作：
       * 1. 存储消息到数据库
       * 2. 标记该联系人已有聊天记录
       */

      // 存储私聊消息到数据库
      const msgres = await service.wxmsgdb.create(payload.data);

      if (msgres) {
        // 标记为已有聊天记录
        await service.wxfriend.editFriend(mywxid, fromWxid, {
          ischat: true,
        });

        // 日志记录
        console.log("私聊消息存储成功:", mywxid, msgtypeText, msgres.date);
      }
    }
  }

  async event10010(payload) {
    const { ctx, service } = this;
    const msgtypeText = await service.chatmsg.isMsgType(
      payload.data.data.msgType
    );
    const msgtype = payload.data.data.msgType;

    if (msgtype !== 10002) {
      const mysend = await service.sendmsg.create(payload.data);
      if (mysend) {
        await service.wxfriend.editFriend(mysend.wxid, mysend.fromWxid, {
          ischat: true,
        });
        console.log("保存自发消息:", payload.wxid, msgtypeText);
      } else {
        console.log(payload.data);
      }
    }
  }

  async event10011(payload) {
    const { ctx } = this;
    const mywxid = payload.wxid;
    // 判断是否开启了自动通过好友请求
    const wxinfo = await ctx.model.Weixindb.findOne({ wxid: mywxid });
    if (wxinfo.isautoPass) {
      await service.wxfriend.agreeFriendReq(mywxid, payload.data.data);
    }
  }

  async event10013(payload) {
    const { ctx } = this;
    const msgId = payload.data.data.msgId;
    if (payload.data.data.msgSource === 1) {
      // 自己撤回
      await ctx.model.Sendmsg.findOneAndDelete({
        msgId,
      });
    } else if (payload.data.data.msgSource === 0) {
      if (payload.data.data.fromType === 1) {
        // 私聊撤回
        await ctx.model.Wxmsgdb.findOne({
          "data.msgId": msgId,
        });
      }
      if (payload.data.data.fromType === 2) {
        // 群聊撤回
        await ctx.model.Wxchatroomdb.findOne({
          "data.msgId": msgId,
        });
      }
    }
  }
}

module.exports = HomeController;
